//tab时间监听

/*
 * layui的初始化模块可以理解为，引入这个模块的js文件
 * 值得注意的是：layui的模块之间存在依赖关系，例如引入了table模块，它会layui/lay/moudules/table.js
 * 这个文件引入进来，并且它还会将这个模块所依赖的其他模块自动加入进来，
 * 实际引入的模块有：table、form、jquery、layer、laypage、laytpl、util，7个js文件
 * 所以我仅仅初始化了table模块，却能获得form、jquery、layer的模块对象
 */
//layui初始化表格模组
layui.use([ 'element', 'table','layer','util' ], function() {
	//表格数据，jquery，Tab的切换功能，切换事件监听等，需要依赖element模块
	var $ = layui.jquery
			, table = layui.table
			, form = layui.form
			,layer = layui.layer
			,element = layui.element
			,util = layui.util;
	
	// 监听tab切换 操作：文档 - 内置模块 - 常用元素操作 element - 监听tab切换
	//基础档案数据表格渲染
	//var archivesTable;
	table.render({
		elem : '#archivesTable',
		url : 'base/archives/archives',
		method : 'get',
		where : {
			status : ''
		} // 你额外要携带数据，以键值对的方式存入
		,toolbar : '#recordToolbar' // 开启头部工具栏，并为其绑定左侧模板
		,cellMinWidth : 80 // 全局定义所有常规单元格的最小宽度（默认：60）
		,cols : [ [ 
		  {type : 'numbers'} // 序号
		, {type : 'checkbox'
		} // 复选框
		//, {field : 'archivesId', title: '基础档案ID', sort: true,unresize : true}
		, {field : 'archivesName', title: '基础档案名', templet: '#archivesNameTpl'}
		//, {field : 'parentId', title: '父级档案ID'}
		, {field : 'parentName', title: '父级档案名'}
		, {field : 'classification', title: '是否分级',templet:function(d){
	    	  if(d.classification == 'N'){
	    		  return "否";
	    	  }else{
	    		  return "是";
	    	  }
	      }}
		, {field : 'description', title: '描述'}
		, {field : 'createTime', title: '创建时间', sort: true, templet: "<div>{{layui.util.toDateString(d.createTime, 'yyyy-MM-dd HH:mm:ss')}}</div>"}
		, {fixed: 'right', align: 'center', title: '是否可用', width: 100, templet: '#checkboxTpl', unresize: true}
		, {fixed: 'right', align: 'center', title: '操作', width: 80, toolbar: '#archivesBar', unresize: true
		} ] ]
		,page : true // 开启分页
		,limit : 10 // 每页显示的条数
		,limits : [ 5, 10, 20, 50, 100 ] // 每页条数的选择项
		,loading : true // 是否显示加载条(切换分页的时候显示）
		,title : '基础档案数据表' // 定义 table 的大标题（在文件导出等地方会用到）
		//,id: 'archivesTable' // 设定容器唯一 id
		//,skin: 'row'
		,even : false// 隔行变色
		//,templet: "<div>{{layui.util.toDateString(d.createTime, 'yyyy-MM-dd HH:mm:ss')}
	});
	
	
	  
	//头部搜索框
	form.on('submit(archivesSearchBtn)', function(data) {
		console.log(data.elem) //被执行事件的元素DOM对象，一般为button对象
		console.log(data.form) //被执行提交的form对象，一般在存在form标签时才会返回
		console.log(data.field) //当前容器的全部表单字段，名值对形式：{name: value}
		
		//刷新数据表格
		table.reload('archivesTable', {//执行重载
			url : 'base/archives/archives',
			where:{
				archivesName:$("#archivesNameSearch").val(),
				classification:$("#classificationSearch").val(),
				useable:$("#useableSearch").val() 
			},
			page: {
				    curr: 1 //重新从第 1 页开始
				  }
			,limit:10
		});
		return false; //阻止表单跳转。如果需要表单跳转，去掉这段即可。
	});
/*--------------------------------------------------------------------------------*/
	
	//检查项目添加到下拉框中
	$.ajax({
		url: 'base/archives/archive/Y',
	  	dataType: 'json',
	  	type: 'GET',
	  	success: function (data) {
	  		$.each(data, function (index, item) {
	  			$('#parentId').append(new Option(item.archivesName, item.archivesId));// 下拉菜单里添加元素
	  		});
	  		form.render("select", "addArchivesForm"); //重新渲染表单下拉框
	  	}
	});
/*-------------------------------------------------------------------------------*/
	
	//头工具栏事件
	table.on('toolbar(archivesTableEvent)', function(obj) {
		//获取当前表格选中状态和选中的数据
		var checkStatus = table.checkStatus(obj.config.id);
		//区分点击的按钮
		switch (obj.event) {
		case 'addRecord':
			//弹出新增模态框
			initAddArchivesModel();
			break;
		case 'updateRecord':
			//选择的数据数量
			if (checkStatus.data.length > 1) {
				layer.msg( "最多只能修改一行数据哦！！", {
					icon : 5, //图标，可输入范围0~6
					time : 2500
				//2秒关闭（如果不配置，默认是3秒）
				});
			} else if (checkStatus.data.length < 1) {
				layer.msg( "请选择要修改的数据！！", {
					icon : 3, //图标，可输入范围0~6
					time : 2500
				//2秒关闭（如果不配置，默认是3秒）
				});
			}else if (checkStatus.data[0].useable == "N") {
				layer.msg( "该基础档案已经被冻结", {
					icon : 3, //图标，可输入范围0~6
					time : 2500
				//2秒关闭（如果不配置，默认是3秒）
				});
			}else {
				//弹出修改模态框，传递当前选中的一行数据过去
				initUpdateArchivesModel(checkStatus.data[0]);
			}
			break;
		case 'frozenRecord':
			//当前选中行的数据
			var data = checkStatus.data;
			//判断是否有选中
			if (checkStatus.data.length < 1) {
				layer.msg( "请选择要禁用的档案！！", {
					icon : 4, //图标，可输入范围0~6
					time : 2500//2秒关闭（如果不配置，默认是3秒）
				});
			}
			//定义一个要删除的所有资源ID的字符串
			var archivesIdStr = "";
			//遍历传递过来的要删除的数据
			for (var i = 0; i < data.length; i++) {
				if (data[i].useable == "N") {
					layer.msg( "所选用户中有被冻结的用户", {
						icon : 4, //图标，可输入范围0~6
						time : 2500
					//2秒关闭（如果不配置，默认是3秒）
					});
					return;
				}
				//拿出资源ID进行拼接
				archivesIdStr += data[i].archivesId + ",";
			}
			//截取掉因为拼接产生的多余的一个逗号
			archivesIdStr = archivesIdStr.substring(0, archivesIdStr.length - 1);
			
			frozenORrecoverArchives(archivesIdStr, "N");
			break;
		case 'recoverRecord':
			//当前选中行的数据
			var data = checkStatus.data;
			//判断是否有选中
			if (checkStatus.data.length < 1) {
				layer.msg( "请选择要禁用的档案！！", {
					icon : 4, //图标，可输入范围0~6
					time : 2500//2秒关闭（如果不配置，默认是3秒）
				});
			}
			//定义一个要删除的所有资源ID的字符串
			var archivesIdStr = "";
			//遍历传递过来的要删除的数据
			for (var i = 0; i < data.length; i++) {
				if (data[i].useable == "Y") {
					layer.msg( "所选数据中有可用的哦！！", {
						icon : 4, //图标，可输入范围0~6
						time : 2500
					//2秒关闭（如果不配置，默认是3秒）
					});
					return;
				}
				//拿出资源ID进行拼接
				archivesIdStr += data[i].archivesId + ",";
			}
			//截取掉因为拼接产生的多余的一个逗号
			archivesIdStr = archivesIdStr.substring(0, archivesIdStr.length - 1);
			
			frozenORrecoverArchives(archivesIdStr, "Y");
			break;
		};
	});

	//监听锁定操作
	form.on('switch(useable)', function(obj) {
		//
		frozenORrecoverArchives(obj.value, this.checked == true ? "Y" : "N");
	});

	//关闭模态框 新增和修改模态框共用这个点击事件
	$(".modalClose").click(function() {
		//关闭页面上所有类型的所有弹框
		layer.closeAll();
	});

	
	//定义冻结或还原的方法
	var frozenORrecoverArchives = function(archivesIdStr, status){
		//基础档案ID
		var archivesId = archivesIdStr;
		//定义提示信息, 状态
		var msg, useable;
		if (status == "Y") {
			msg = "还原", useable = "Y";
		} else {
			msg = "禁用", useable = "N";
		}
		//发送异步请求冻结或还原资源
		$.ajax({
			async : false, //默认为true，false表示同步，如果当前请求没有返回则不执行后续代码
			type : "post",
			url : 'base/archives/archive/'+archivesId+"/"+useable,
			data : {
				_method: 'DELETE'
			},
			datatype : 'json',
			success : function(result) {
				if (result == "success") {
					layer.msg(msg + "成功！", {
						icon : 1, //图标，可输入范围0~6
						time : 2500
					//2秒关闭（如果不配置，默认是3秒）
					});
				} else {
					layer.msg(msg + "失败！", {
						icon : 2,
						time : 2500
					});
				}
				//刷新数据表格
				table.reload('archivesTable', {
					url : 'base/archives/archives'
				});
			}
		});
	}

	//初始化新增模态框
	var initAddArchivesModel = function() {
		openModal({ //弹模态框调用方法模板（修改值即可）
			type: 1, // 基本层类型0~4，1为页面层
			title: '添加基础档案', // 标题
			width: '500px', // 宽度
			height: '400px', // 高度
			modalId: 'addArchivesModel', // 模态框id不用加 # 符号
			anim: 0, // 弹出动画
			resize: false, // 是否允许拉伸
			btnAlign: 'c', // 按钮'c'居中...
			ajaxType: 'post', // ajax请求方式
			ajaxUrl: 'base/archives/archive', // ajax请求地址
			ajaxAsync: true, // ajax是否异步请求
			reloadTabId: 'archivesTable', // 刷新表数据的表 id 不用加 # 符号
			reloadTabUrl: 'base/archives/archives', // 刷新表数据请求的url
			ifOk: {
				funName: addArchivesOk, // 提交成功回调函数名（不能是数字和字符串也不能带括号，有模板函数fun1/自定义）
				parameter: {} // 传入提交成功回调函数的参数json
			},
			ifErr: {
				funName: addArchivesErr, // 提交失败回调函数名（不能是数字和字符串也不能带括号，有模板函数fun2/自定义）
				parameter: {} // 传入提交失败回调函数的参数json
			},
			modalFormVerify: { // 校验（无校验可不要/删掉,建议:写校验函数,！--注意：该上传非submit提交，layui的表单校验无效--！）
				funName: addVerify, // 校验函数名（不能是数字和字符串也不能带括号，返回值必须是true才能提交，有模板函数fun3/自定义）
				parameter: {} // 传入校验函数的参数json
			}
		})
	}
	
	
	//初始化查看模态框
	var initSearchModel = function() {
		//弹出一个页面层
		layer.open(
			{type : 1 // 基本层类型0~4，1为页面层
			,title : '查看辅助档案' // 标题
			//,skin : 'layui-layer-molv'//设置表头颜色
			,area : '700px' // 宽高 只写一个参数就是表示宽度，高度会自适应
			,content : $("#Subset") // 文本、html都行
			,anim : 0 // 弹出动画
			,resize : false // 是否允许拉伸
			,end : function() { // 弹出层销毁时的回调函数（不论何种方式，只要关闭了就执行）
				//清空表单
				//$("#Subset")[0].reset();
			}
		});
	}

	//初始化修改模态框
	var initUpdateArchivesModel = function(data) {
		openModal({ //弹模态框调用方法模板（修改值即可）
			type: 1, // 基本层类型0~4，1为页面层
			title: '修改基础档案', // 标题
			width: '500px', // 宽度
			height: '400px', // 高度
			modalId: 'updateArchivesModel', // 模态框id不用加 # 符号
			anim: 0, // 弹出动画
			resize: false, // 是否允许拉伸
			btnAlign: 'c', // 按钮'c'居中...
			ajaxType: 'post', // ajax请求方式
			ajaxUrl: 'base/archives/archive', // ajax请求地址
			ajaxAsync: true, // ajax是否异步请求
			reloadTabId: 'archivesTable', // 刷新表数据的表 id 不用加 # 符号
			reloadTabUrl: 'base/archives/archives', // 刷新表数据请求的url
			ifOk: {
				funName: updateArchivesOk, // 提交成功回调函数名（不能是数字和字符串也不能带括号，有模板函数fun1/自定义）
				parameter: {} // 传入提交成功回调函数的参数json
			},
			ifErr: {
				funName: updateArchivesErr, // 提交失败回调函数名（不能是数字和字符串也不能带括号，有模板函数fun2/自定义）
				parameter: {} // 传入提交失败回调函数的参数json
			},
			modalFormVerify: { // 校验（无校验可不要/删掉,建议:写校验函数,！--注意：该上传非submit提交，layui的表单校验无效--！）
				funName: updateVerify, // 校验函数名（不能是数字和字符串也不能带括号，返回值必须是true才能提交，有模板函数fun3/自定义）
				parameter: {} // 传入校验函数的参数json
			}
		})

		//表单赋值
		form.val('updateArchivesForm', {
			"archivesId" : data.archivesId
			,"archivesName" : data.archivesName
			,"classification" : data.classification
			,"description" : data.description
			,"useable" : data.useable
		});
	}
	
	form.on('select',function(data){
		switch($(data.elem).attr('id')){
		case 'parentId':
			$(".definedModal input[name='parentName']").val($(data.elem).children("option[value='"+$(data.elem).val()+"']").text());
			break;
		}
	});
	
	// 提交成功回调函数模板
	function updateArchivesOk(e) {
		if(e.respData == true) {
			layer.closeAll();
			layer.msg("修改成功", {
				icon: 1, //图标，可输入范围0~6
				time: 2500 //2秒关闭（如果不配置，默认是3秒）
			});
		} else {
			layer.msg("修改失败，请重试！", {
				icon: 1, //图标，可输入范围0~6
				time: 2500 //2秒关闭（如果不配置，默认是3秒）
			});
		}
		table.reload('archivesTable', {
			url: "base/archives/archives"
		});
	}

	// 提交失败回调函数模板
	function updateArchivesErr() {
		layer.msg("修改失败，请重试！", {
			icon: 1, //图标，可输入范围0~6
			time: 2500 //2秒关闭（如果不配置，默认是3秒）
		});
	}
	// 提交成功回调函数模板
	function addArchivesOk(e) {
		if(e.respData == true) {
			layer.closeAll();
			layer.msg("添加成功", {
				icon: 1, //图标，可输入范围0~6
				time: 2500 //2秒关闭（如果不配置，默认是3秒）
			});
		} else {
			layer.msg("添加失败，请重试！", {
				icon: 1, //图标，可输入范围0~6
				time: 2500 //2秒关闭（如果不配置，默认是3秒）
			});
		}
		table.reload('archivesTable', {
			url: "base/archives/archives"
		});
	}

	// 提交失败回调函数模板
	function addArchivesErr() {
		layer.msg("添加失败，请重试！", {
			icon: 1, //图标，可输入范围0~6
			time: 2500 //2秒关闭（如果不配置，默认是3秒）
		});
	}
	// 表单校验函数模板
	function addVerify() {
		var verifyOkNum = 0; //定义校验通过数量

		//自定义校验方法（修改即可）根据元素中my-verify属性的值进行校验没有可以自己添加（跟layui的一样写法）
		myVerify({
			addArchivesName: function(value) {
				if(value == '' || value == null) {
					return '基础档案名不能为空';
				} else if(!new RegExp("^[a-zA-Z0-9_\u4e00-\u9fa5\\s·]+$").test(value)) {
					return '基础档案名不能有特殊字符';
				} else if(/(^\_)|(\__)|(\_+$)/.test(value)) {
					return '基础档案名首尾不能出现下划线\'_\'';
				} else if(/^\d+\d+\d$/.test(value)) {
					return '基础档案名不能全为数字';
				}
				/* else if(从数据库查组织结构名函数的返回值（组织id） != 组织结构id && 从数据库查组织结构名函数的返回值（组织id） != "") {
					return '该组织名已存在';
				}*/
				{
					verifyOkNum++;
					return null;
				}
			}
		});
		//
		if(verifyOkNum == 1) { //当校验通过数量==要校验的数量时返回true
			return true;
		} else {
			return false;
		}
	}
	
	// 表单校验函数模板
	function updateVerify() {
		var verifyOkNum = 0; //定义校验通过数量

		//自定义校验方法（修改即可）根据元素中my-verify属性的值进行校验没有可以自己添加（跟layui的一样写法）
		myVerify({
			updateArchivesName: function(value) {
				if(value == '' || value == null) {
					return '基础档案名不能为空';
				} else if(!new RegExp("^[a-zA-Z0-9_\u4e00-\u9fa5\\s·]+$").test(value)) {
					return '基础档案名不能有特殊字符';
				} else if(/(^\_)|(\__)|(\_+$)/.test(value)) {
					return '基础档案名首尾不能出现下划线\'_\'';
				} else if(/^\d+\d+\d$/.test(value)) {
					return '基础档案名不能全为数字';
				}
				/* else if(从数据库查组织结构名函数的返回值（组织id） != 组织结构id && 从数据库查组织结构名函数的返回值（组织id） != "") {
					return '该组织名已存在';
				}*/
				{
					verifyOkNum++;
					return null;
				}
			}
		});
		//
		if(verifyOkNum == 1) { //当校验通过数量==要校验的数量时返回true
			return true;
		} else {
			return false;
		}
	}
	//判断选择的条件，给异步加事件
	form.on('select(classification)', function(data){console.log(data)
		if (data.value == "N") {
			$("#addArchivesForm #parentId").removeAttr("disabled");
			
		} else {
			$("#addArchivesForm #parentId").attr("disabled", true);
			
		}
		form.render("select", "addArchivesForm");
	});  
	
	
	//监听工具条
	table.on('tool(archivesTableEvent)', function(obj){
	  var data = obj.data;
	  if(obj.event === 'detail'){
	    table.render({
			elem : '#SeacherSubset',
			url : "base/subset/subset/"+data.archivesId,
			method : 'post',
			where : {
				
			}
			,cols : [[ 
			  {type : 'numbers'} // 序号
			//, {type : 'checkbox'
			//} // 复选框
			, {field : 'subsetName',title : '辅助档案名',sort: true,unresize : true}
			, {field : 'useable',title : '是否可用',templet:function(d){
		    	  if(d.classification == 'N'){
		    		  return "否";
		    	  }else{
		    		  return "是";
		    	  }
		      }}
			, {field : 'description',title : '描述'}
			, {field : 'createTime',title : '创建时间',sort: true,templet: "<div>{{layui.util.toDateString(d.modifyDate, 'yyyy-MM-dd HH:mm:ss')}}</div>"},
			]]
			//,skin: 'row'
			,even : false// 隔行变色
		});
	   
	    initSearchModel();
	  } 
	});
	
	
	//监听行单击事件（双击事件为：rowDouble）
	 table.on('rowDouble(archivesTableEvent)', function(obj){
	    var data = obj.data;
	    console.log(obj.tr) //得到当前行元素对象
	    console.log(obj.data) //得到当前行数据
	    $.ajax({
	    	type:"post",
	    	url:"base/subset/subset/"+data.archivesId,
	    	data:{
	    		
	    	},
	    	success:function(data){
	    		//alert(data.length);
	    		if(data.length == 0){
	    			layer.msg("此档案下没有辅助档案！", {
						icon : 1, //图标，可输入范围0~6
						time : 2500//2秒关闭（如果不配置，默认是3秒）
					});
	    		}else{
	    			layer.alert(JSON.stringify(data), {
		    		      title: '参考此档案的辅助档案：'
		    		      
		    		});
	    		}
	    		
	    	}
	    });
	    
	    //标注选中样式
	    obj.tr.addClass('layui-table-click').siblings().removeClass('layui-table-click');
	    //选中行，勾选复选框
	    //obj.tr.find("div.layui-unselect.layui-form-checkbox")[1].click();
	 });
	 
	 
	 /*----------------------------------------------------*/
	 
		

		/*------------------打开模态框的主方法（放在layui.use(['table'], function() {}（必须要定义了var form = layui.form,layer = layui.layer,table = layui.table,$ = layui.jquery;）里面）不能私自修改，折叠起来-------------------------------------------------------------------*/
		function openModal(modalDatas) {
			if(typeof(modalDatas.selectList) !== 'undefined') {
				loadOption(modalDatas.selectList);
			}

			layer.open({
				type: modalDatas.type, // 基本层类型0~4，1为页面层
				title: modalDatas.title, // 标题
				area: [modalDatas.width, modalDatas.height], // 宽高 只写一个参数就是表示宽度，高度会自适应
				content: $("#" + modalDatas.modalId), // 文本、html都行
				anim: modalDatas.anim, // 弹出动画
				resize: modalDatas.resize, // 是否允许拉伸
				btnAlign: modalDatas.btnAlign, //按钮居中
				btn: ['立即提交', '关闭'], //按钮文字
				btn1: function(index, layero) { //（btn1：‘立即提交’）   回调函数
					if(modalDatas.modalFormVerify != '' && typeof(modalDatas.modalFormVerify) !== 'undefined') {
						if(typeof(modalDatas.modalFormVerify.funName) === 'function' && modalDatas.modalFormVerify.funName(modalDatas.modalFormVerify.parameter) == true) {
							setModalAjaxData();
						} else {
							console.log('你的校验未通过！')
						}
					} else {
						setModalAjaxData();
					}

				},
				btn2: function(index, layero) { //（btn2：‘关闭’） 回调函数
					//关闭页面上所有类型的所有弹框
					layer.closeAll();
				},
				end: function() { // 弹出层销毁时的回调函数（不论何种方式，只要关闭了就执行）
					//清空表单
					$("#" + modalDatas.modalId + " form")[0].reset();
					if(typeof(modalDatas.selectList) !== 'undefined') {
						claseOption(modalDatas.selectList); //在''里面填要清空的select的id
					}
				}
			});

			function setModalAjaxData() {
				var formData = {};
				$.map($("#" + modalDatas.modalId + " form").serializeArray(), function(object, index) {
					formData[object['name']] = object['value'];
				});
				if(modalDatas.ajaxType == '' || typeof(modalDatas.ajaxType) === 'undefined') {
					modalDatas.ajaxType = 'post';
				}
				if(modalDatas.ajaxAsync == '' || typeof(modalDatas.ajaxAsync) === 'undefined') {
					modalDatas.ajaxAsync = true;
				}
				modalAjax({
					formData: formData,
					thisType: modalDatas.ajaxType,
					thisUrl: modalDatas.ajaxUrl,
					thisAsync: modalDatas.ajaxAsync,
					thisOkFun: {
						funName: modalDatas.ifOk.funName,
						parameter: modalDatas.ifOk.parameter
					},
					thisErrFun: {
						funName: modalDatas.ifErr.funName,
						parameter: modalDatas.ifErr.parameter
					}
				});
			}

			//提交表单函数
			function modalAjax(modalSubmitData) {
				$.ajax({
					type: modalSubmitData.thisType,
					url: modalSubmitData.thisUrl,
					async: modalSubmitData.ajaxAsync,
					data: modalSubmitData.formData,
					dataType: 'json',
					success: function(respData) {
						if(typeof(modalSubmitData.thisOkFun.funName) === 'function') {
							modalSubmitData.thisOkFun.funName({
								respData: respData,
								parameter: modalSubmitData.thisOkFun.parameter
							});
						}
					},
					error: function() {
						if(typeof(modalSubmitData.thisErrFun.funName) === 'function') {
							modalSubmitData.thisErrFun.funName(modalSubmitData.thisErrFun.parameter);
						}
					}
				});
			}

			function addOption(obj) {
				if(obj.respData != '' && typeof(obj.respData) != 'undefined') {
					$.each(obj.respData, function(index, o) {
						$("#" + modalDatas.modalId + " #" + obj.parameter.selectId).append(new Option(o[obj.parameter.optionTxt], o[obj.parameter.optionVal]));
					});
					form.render(); //渲染将option添加进去
				}
			}
			//清空select的option方法
			function claseOption(selectList) {
				if(typeof(selectList) !== 'undefined') {
					$.each(selectList, function(index, o) {
						if(o.selectId != '' && typeof(o.selectId) !== 'undefined') {
							$("#" + modalDatas.modalId + " #" + o.selectId).html("<option value=''></option>");
						}
					});
				}
			}

			function loadOptionErr() {
				layer.msg("请求超时，数据加载失败！", {
					icon: 1,
					time: 2500
				});
			}

			//清空select的option方法
			function loadOption(selectList) {
				$.each(selectList, function(index, o) {
					if(o.selectId != '' && typeof(o.selectId) != undefined) {
						if(o.selectType == '' || typeof(o.selectType) === 'undefined') {
							o.selectType = 'get';
						}
						modalAjax({
							formData: {},
							thisType: o.selectType,
							thisUrl: o.selectUrl,
							thisAsync: false,
							thisOkFun: {
								funName: addOption,
								parameter: o
							},
							thisErrFun: {
								funName: loadOptionErr
							}
						});
					}
				});
			}
		}
		/*------------------打开模态框的主方法（放在layui.use(['table'], function() {}（必须要定义了var form = layui.form,layer = layui.layer,table = layui.table,$ = layui.jquery;）里面）不能私自修改，折叠起来-------------------------------------------------------------------*/

		/*------------------自定义校验方法（调用即可，！--注意：不可私自修改--！）------------------------*/
		function myVerify(myVerifyData) { //自定义校验方法（调用即可，！--注意：折叠起来，不可私自修改--！）
			if(typeof(myVerifyData) !== 'undefined' && myVerifyData != '') {
				$.each(myVerifyData, function(name) {
					var myVerifyReturnVal = myVerifyData[name]($("input[my-verify=" + name + "]").val());
					if(myVerifyReturnVal != null && typeof(myVerifyReturnVal) !== 'undefined') {
						//"<div style='position: relative'><span style='color: red; font-size: 12px; position: absolute;'>"+$("input[my-verify=" + name + "]").val()+"</span></div>"
						$("input[my-verify=" + name + "]").css('border-color', 'rgb(255,87,34)');
						$("input[my-verify=" + name + "]").next().remove();
						$("input[my-verify=" + name + "]").parent().append("<div class='myVerifyErr' style='position: relative'><span style='color: red; font-size: 12px; position: absolute;'>" + myVerifyData[name]($("input[my-verify=" + name + "]").val()) + "</span></div>")
					}
				});
				setTimeout(removeMyVerifyErr, 2000);

				function removeMyVerifyErr() {
					$(".myVerifyErr").remove();
					$("form input[name!='button']").css('border-color', 'rgb(230,230,230)');
				}
			}
		}
	 

});
